package io.adminboot.system.redis;

import org.springframework.data.redis.core.ZSetOperations.TypedTuple;

import java.util.Collection;
import java.util.List;
import java.util.concurrent.TimeUnit;

public interface IRedisClient {

    /**
     * 模糊查询keys
     *
     * @param pattern
     * @return
     */
    Collection<String> keys(String pattern);

    /***
     * 根据key删除缓存
     * @param key
     */
    void delete(String key);

    /**
     * 根据key集合删除缓存
     *
     * @param key
     */
    void delete(Collection<String> key);

    /**
     * 根据key相对应的value
     *
     * @param key
     * @param clazz
     * @return
     */
    <T> T get(String key, Class<T> clazz);

    /**
     * 根据key获取缓存集合
     *
     * @param keys
     * @param clazz
     * @return
     */
    <T> List<T> mget(Collection<String> keys, Class<T> clazz);

    /**
     * 设置缓存
     *
     * @param key
     * @param value
     * @param timeout 缓存过期时间 <=0则不过期
     * @param unit    时间单位
     */
    void set(String key, Object value, long timeout, TimeUnit unit);

    /**
     * 设置键的值并返回其旧值。
     *
     * @param key
     * @param obj
     * @param clazz
     * @return
     */
    <T> T getAndSet(String key, Object obj, Class<T> clazz);

    /**
     * 递减操作
     *
     * @param key
     * @param delta
     * @return
     */
    int decrement(String key, int delta);

    /**
     * 递增操作
     *
     * @param key
     * @param delta
     * @return
     */
    int increment(String key, int delta);

    /**
     * 获取key的列表数量
     *
     * @param key
     * @return
     */
    int size(String key);

    /**
     * 根据key获取从开始和结束之间的元素
     *
     * @param key
     * @param start
     * @param end
     * @param clazz
     * @return
     */
    <T> List<T> range(String key, long start, long end, Class<T> clazz);

    /**
     * 附加值到某个key
     *
     * @param key
     * @param values
     * @param timeout
     * @param unit
     */
    void rightPushAll(String key, Collection<?> values, Long timeout,
                      TimeUnit unit);

    /**
     * 压栈
     *
     * @param key
     * @param obj
     */
    <T> void leftPush(String key, T obj);

    /**
     * 出栈
     *
     * @param key
     * @param clazz
     * @return
     */
    <T> T leftPop(String key, Class<T> clazz);

    /**
     * 入队列
     *
     * @param key
     * @param obj
     * @return
     */
    Long queueIn(String key, Object obj);

    /**
     * 出队列
     *
     * @param key
     * @return
     */
    <T> T queueOut(String key, Class<T> clazz);

    /**
     * 获取队列长度
     *
     * @param key
     * @return
     */
    Long queueLength(String key);

    /**
     * 从{key}中存储的列表中移除“{object}”的第{count}个的出现。
     *
     * @param key
     * @param count
     * @param obj
     */
    void remove(String key, int count, Object obj);

    /**
     * 根据key关键字获取排序集大小
     *
     * @param key
     * @return
     */
    int zcard(String key);

    /**
     * 根据key获取有序集合从开始和结束之间的元素
     *
     * @param key
     * @param start
     * @param end
     * @param clazz
     * @return
     */
    <T> List<T> zrange(String key, long start, long end, Class<T> clazz);

    /**
     * 在关键字的排序集上添加值，或在已存在时更新其值。
     *
     * @param key
     * @param obj
     * @param score
     */
    void zadd(String key, Object obj, double score);

    /**
     * 在关键字的排序集上添加值，或在已存在时更新其值。
     *
     * @param key
     * @param tupleList
     * @param timeout
     * @param unit
     */
    void zaddAll(String key, List<TypedTuple<?>> tupleList, Long timeout, TimeUnit unit);

    /**
     * 从排序集移除值。返回移除元素的返回数。
     *
     * @param key
     * @param obj
     */
    Long zrem(String key, Object obj);

    /**
     * 有序集合的key和otherkeys存储在目标destkey结果
     *
     * @param destKey
     * @param keys
     * @param timeout
     * @param unit
     */
    void unionStore(String destKey, Collection<String> keys, Long timeout, TimeUnit unit);

}
